package com.star.service;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import junit.framework.Test;

public class otherABsPanel {

	 
	    private static int total;
	    private static int m = 3;
	    public static void main(String[] args) {
	        List<Integer> iL = new ArrayList<Integer>();
	      plzh("", iL,  m,"1234");
	     
	    }
	private static void plzh(String s, List<Integer> iL, int m,String isn) {
		String[] d=isn.split("");
		String[] is = new String[] {d[1],  d[2],  d[3],  d[4]};
	        if(m == 0) {
	            String[] mun=s.split("");
	           int n=(Integer.parseInt(mun[1])+Integer.parseInt(mun[2])+Integer.parseInt(mun[3]))%10;
	           System.out.println(n);
	            return;
	        }
	        List<Integer> iL2;
	        for(int i = 0; i < is.length; i++) {
	            iL2 = new ArrayList<Integer>();
	            iL2.addAll(iL);
	            if(!iL.contains(i)) {
	                String str = s + is[i];
	                iL2.add(i);
	                plzh(str, iL2, m-1,isn);
	            }
	        }
	}

	//两合见数
    public static boolean permutation(String l,String str){  
    	//String str = "3456";
    	boolean rs=false;
        char[] arr = str.toCharArray();
        char[] larr = l.toCharArray();
        
        String[] array = new String[]{String.valueOf(arr[0]),String.valueOf(arr[1]),String.valueOf(arr[2]),String.valueOf(arr[3])};
        String result = "";
        for (int i = 0; i < array.length; i++) {
            for (int j = i + 1; j < array.length; j++) {
                if(i < array.length - 2){
                	for (char c  : larr) {
                		 if(((Integer.parseInt(array[i]) +Integer.parseInt(array[j]))%10)==Integer.parseInt(String.valueOf(c))){
                         	return true;
                         }
					}
                   
                }else{
                	for (char c  : larr) {
                	if(((Integer.parseInt(array[i]) +Integer.parseInt(array[j]))%10)==Integer.parseInt(String.valueOf(c))){
                    	return true;
                    }
                	}
                }
            }
        }
        return rs;
    } 
    /** 数组元素的全组合 */
    static void combination(char[] chars) {
        char[] subchars = new char[chars.length]; //存储子组合数据的数组
        //全组合问题就是所有元素(记为n)中选1个元素的组合, 加上选2个元素的组合...加上选n个元素的组合的和
        for (int i = 0; i < chars.length; ++i) {
            final int m = i + 1;
            combination(chars, chars.length, m, subchars, m);
        }
    }

    /**
     *  n个元素选m个元素的组合问题的实现. 原理如下:
     *  从后往前选取, 选定位置i后, 再在前i-1个里面选取m-1个.
     *  如: 1, 2, 3, 4, 5 中选取3个元素.
     *  1) 选取5后, 再在前4个里面选取2个, 而前4个里面选取2个又是一个子问题, 递归即可;
     *  2) 如果不包含5, 直接选定4, 那么再在前3个里面选取2个, 而前三个里面选取2个又是一个子问题, 递归即可;
     *  3) 如果也不包含4, 直接选取3, 那么再在前2个里面选取2个, 刚好只有两个.
     *  纵向看, 1与2与3刚好是一个for循环, 初值为5, 终值为m.
     *  横向看, 该问题为一个前i-1个中选m-1的递归.
     */
    static void combination(char[] chars, int n, int m, char[] subchars, int subn) {
        if (m == 0) { //出口
            for (int i = 0; i < subn; ++i) {
                System.out.print(subchars[i]);
            }
            System.out.println();
        } else {
            for (int i = n; i >= m; --i) { // 从后往前依次选定一个
                subchars[m - 1] = chars[i - 1]; // 选定一个后
                combination(chars, i - 1, m - 1, subchars, subn); // 从前i-1个里面选取m-1个进行递归
            }
        }
    }

    /** 数组元素的全排列 */
    static void permutation(char[] chars) {
        permutation(chars, 0, chars.length - 1);
    }

    /** 数组中从索引begin到索引end之间的子数组参与到全排列 */
    static void permutation(char[] chars, int begin, int end) {
        if (begin == end) { //只剩最后一个字符时为出口
            for (int i = 0; i < chars.length; ++i) {
                System.out.print(chars[i]);
            }
            System.out.println();
        } else {
            for (int i = begin; i <= end; ++i) { //每个字符依次固定到数组或子数组的第一个
                if (canSwap(chars, begin, i)) { //去重
                    swap(chars, begin, i); //交换
                    permutation(chars, begin + 1, end); //递归求子数组的全排列
                    swap(chars, begin, i); //还原
                }
            }
        }
    }

    static void swap(char[] chars, int from, int to) {
        char temp = chars[from];
        chars[from] = chars[to];
        chars[to] = temp;
    }

    static boolean canSwap(char[] chars, int begin, int end) {
        for (int i = begin; i < end; ++i) {
            if (chars[i] == chars[end]) {
                return false;
            }
        }
        return true;
    }
}
